When printing a type `C^` where `C` extends `Capability`, don't show the `^`.
This is overridden under -Yprint-debug.

Add dedicated tests `isMutableVar` and `isMutableVarOrAccessor`
where we now check for the `Mutable` flag. This will allow to use
`Mutable` also for update methods, so that we don't have to burn
another flag bit for them.

Also, add design document from papers to docs/internals

…table

…e capture sets.

This means Mutable classes get {cap.rd} as default capture set.

….toCap

If existentials are mapped to fresh, it matters where they are opened. Pure or not
arguments don't have anything to do with that.

Don't add elements to hidden sets if they were subsumed previously.

 - Always store new types on rechecking
 - Store them in a hashmap which is associated with the rechecker of the
   current compilation unit
 - After rechecking is done, the map is forgotten, unless keepTypes is true.
   Under keepTypes, then map is kept in an attachment of the unit's root tree.

Change in nomenclature:

    knownType --> nuType
    rememberType --> setNuType
    hasRememberedType --> hasNuType

…uctorType

 - Use unsafeAssumeSeparate(...) as an escape hatch

 - In ++, use a FrozenSepState in order not to pollute hidden sets
 - This avoids two spurious separation failures in stdlib

The subsumes check mistakenly allowed any capability to subsume `cap`, since `cap` is expanded
as `caps.cap`, and by the path subcapturing rule `caps.cap <: caps`, where the capture set of
`caps` is empty. This allowed quite a few hidden errors to go through. This commit fixes the
subcapturing issue and all downstream issues caused by that fix.

In particular:

 - Don't use path comparison for `x subsumes caps.cap`

 - Don't allow an opened existential on the left of a comparison to leak into a capture set on
   the right. This would give a "leak" error later in healCaptures.

 - Print `Fresh.Cap` as `fresh` in error messages where both `cap` and `Fresh.Cap` are printed.
   This avoid confustion with `cap`. Similarly, print `A => B` as `A ->{fresh B` in that case.

 - Print pre-cc annotated capturing types with @retains annotations with `^`. The annotation is
   already rendered as a set in this case, but the `^` was missing.

 - Don't recheck `_` right hand sides of uninitialized variables. These were handled in ways
   that broke freshness checking. The new `uninitialied` scheme does not have this problem.

 - Convert cap to fresh in type arguments of asInstanceOf

 - Have Fresh.FromCap also work for pre-cc @retains annotated types

 - Don't cache captureSetOfInfos under mode IgnoreCaptures

 - Let cap and Fresh.Cap subsume other refs only if these others refs cannot
   be added separately to a capture set.

 - When creating a instance of a capability class, assume fresh.cap, not cap as capability.

Three tests had to be disabled, they were renamed from test.scala to test.scala.disabled.
Two of these will work again when we stop boxing alias types (next commit). The third,
ex-fun-aliases needs more investigation. Also, the neg test box-adapt-cases needs
to be re-evaluated.

This is necessary because the compiler is free in previous phases to dealias or not.
Therefore, capture checking should not depend on aliasing. The main difference is that
now arguments to type aliases are not necessarily boxed. They are boxed only if they need
boxing in the dealiased type.

The previous meaning did not do enough in the presence of fresh.
The new meaning is that all universal capture sets under a @uncheckedCaptures
become <fluid> capture sets.